package cn.tedu.charging.perm.service.impl;

import cn.tedu.charging.perm.mapper.PermMapper;
import cn.tedu.charging.perm.pojo.po.Perm;
import cn.tedu.charging.perm.service.PermService;
import cn.tedu.charging.perm.pojo.param.PermQuery;
import cn.tedu.charging.perm.pojo.param.PermSaveParam;
import cn.tedu.charging.perm.pojo.po.RolePerm;
import cn.tedu.charging.perm.pojo.vo.PermVO;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Slf4j
@Service
public class PermServiceImpl implements PermService {
    @Autowired
    PermMapper permMapper;
    @Override
    public List<PermVO> selectPerm(PermQuery permQuery) {
        log.debug("查询权限业务层的入参为{}",permQuery);

        if (permQuery.getRoleId()==null){
            log.debug("此次查询没有角色Id");
            log.debug("查询业务层调用mapper层的入参为{}",permQuery);
            List<PermVO> list = permMapper.selectPerm(permQuery);
            log.debug("查询业务层调用mapper层的入参为{}出参为{}",permQuery,list);
            log.debug("将父级权限id转换为父级权限姓名并调用的入参为{}",list);
            List<PermVO> permVOS1 = getHavePrentNamePermVOS(list);
            log.debug("将父级权限id转换为父级权限姓名并调用的入参为{}出参为{}",list,permVOS1);
            List<PermVO> difference = difference(list, permVOS1);
            permVOS1.addAll(difference);
            return permVOS1;
        }

//        此时查到的为不含角色Id的权限
//        此时要查含有角色Id的权限
        if (permQuery.getRoleId()!=null){
            RolePerm rolePerm = new RolePerm();
            rolePerm.setRoleId(permQuery.getRoleId());
            List<RolePerm> rolePerms = selectRolePerm(rolePerm);
            List<PermVO> list=new ArrayList<>();
            for (int i =0;i<rolePerms.size();i++) {
//            获取权限id
                Long permId = rolePerms.get(i).getPermId();
//            新建查询条件
                PermQuery permQuery1 = new PermQuery();
//            给查询条件赋值权限id
                permQuery1.setId(permId);
//
                List<PermVO> permVOS = permMapper.selectPerm(permQuery1);

                list.add(permVOS.get(0));
            }
            List<PermVO> havePrentNamePermVOS = getHavePrentNamePermVOS(list);
            log.debug("查询业务层调用mapper层的入参为{}出参为{}",permQuery,havePrentNamePermVOS);
            List<PermVO> difference = difference(list, havePrentNamePermVOS);
            havePrentNamePermVOS.addAll(difference);
            return havePrentNamePermVOS;
        }
return null;

    }

    @NotNull
    private List<PermVO> getHavePrentNamePermVOS( List<PermVO> list) {
        log.debug("使parentId转换为含有父级权限名的集合");
        List<PermVO> permVOS1 = new ArrayList<>();
//            将查询到的父级权限转换为名称
        for (int i = 0; i < list.size(); i++) {
            log.debug("进入循环");
            if (list.get(i).getParentId()!=null){
                log.debug("进入循环");
                PermQuery permQuery1 = new PermQuery();
                Long parentId = list.get(i).getParentId();
                permQuery1.setId(parentId);
                log.debug("此时通过传输的入参中实体的parentId去调用mapper层的接口入参为{}",permQuery1);
                List<PermVO> permVOS = permMapper.selectPerm(permQuery1);
                log.debug("此时通过传输的入参中实体的parentId去调用mapper层的接口入参为{}出参为{}",permQuery1,permVOS);
                log.debug("将获取到的集合中的实体的权限名赋值给传进来的集合的元素的parentName");
                String permName = permVOS.get(0).getPermName();
                log.debug("将获取到的集合中的实体的权限名赋值给传进来的集合的元素的parentName permName{}",permName);
                PermVO permVO = list.get(i);
                log.debug("permVO{}",permVO);
                permVO.setParentName(permName);
                log.debug("赋值后permVO{}",permVO);
                permVOS1.add(permVO);
                log.debug("此时要被返回的出参值为{}",permVOS1);
            }
        }
        log.debug("返回的出参值为{}",permVOS1);
        return permVOS1;
    }

    @Override
    public void savePerm(PermSaveParam permSaveParam) {
        log.debug("保存权限业务层的入参为{}",permSaveParam);
        if (permSaveParam.getId()==null){
            Perm perm = new Perm();
            BeanUtils.copyProperties(permSaveParam,perm);
            perm.setCreateTime(new Date());
            log.debug("保存业务层调用mapper层的插入接口入参为{}",perm);
            permMapper.insert(perm);
        }else {
            UpdateWrapper<Perm> permUpdateWrapper = new UpdateWrapper<>();
            permUpdateWrapper.eq("id",permSaveParam.getId());
            Perm perm = new Perm();
            BeanUtils.copyProperties(permSaveParam,perm);
            perm.setUpdateTime(new Date());
            log.debug("保存业务层调用mapper层的更新接口入参为{}",perm);
            permMapper.update(perm,permUpdateWrapper);

        }


        log.debug("保存业务层的入参为{}没有出参",permSaveParam);
    }

    @Override
    public void deletePerm(Long permId) {
        log.debug("删除权限业务层的入参为{}",permId);
        log.debug("删除业务层调用mapper层的入参为{}",permId);
        permMapper.deleteById(permId);
        log.debug("删除业务层调用mapper层的入参为{}没有出参",permId);
    }

    @Override
    public void addRolePerm(Long roleId, Long permId) {
        log.debug("添加角色权限业务层的入参为{}{}",roleId,permId);
        log.debug("添加角色权限业务层调用mapper层的入参为{}{}",roleId,permId);
        RolePerm rolePerm = new RolePerm();
        rolePerm.setRoleId(roleId);
        rolePerm.setPermId(permId);
        permMapper.insertRolePerm(rolePerm);
        log.debug("添加角色权限业务层调用mapper层的入参为{}{}没有出参",roleId,permId);

    }

    @Override
    public void deleteRolePerm(Long roleId, Long permId) {
        log.debug("删除角色权限业务层的入参为{}{}",roleId,permId);
        log.debug("删除角色权限业务层调用mapper层的入参为{}{}",roleId,permId);
        RolePerm rolePerm = new RolePerm();
        rolePerm.setRoleId(roleId);
        rolePerm.setPermId(permId);
        permMapper.deleteRolePerm(rolePerm);
        log.debug("删除角色权限业务层调用mapper层的入参为{}{}没有出参",roleId,permId);
    }

    @Override
    public List<RolePerm> selectRolePerm(RolePerm rolePerm) {
        log.debug("查询角色权限业务层的入参为{}",rolePerm);
        log.debug("查询角色权限业务层调用mapper层的入参为{}",rolePerm);
        List<RolePerm> list = permMapper.selectRolePerm(rolePerm);
        log.debug("查询角色权限业务层调用mapper层的入参为{}出参为{}",rolePerm,list);
        return list;
    }

    @Override
    public List<PermVO> selectUnBindPerm(Long roleId) {
        log.debug("查询未绑定权限业务层的入参为{}",roleId);
        log.debug("查询所有权限");
        List<PermVO> permVOS = selectPerm(new PermQuery());
        log.debug("查询所有权限的出参为{}",permVOS);
        PermQuery permQuery = new PermQuery();
        permQuery.setRoleId(roleId);
        log.debug("获取此角色所含有的权限的入参为{}",permQuery);
        List<PermVO> permVOS1 = selectPerm(permQuery);
        log.debug("获取此角色所含有的权限的入参为{}出参为{}",permQuery,permVOS1);
        log.debug("获取此角色未绑定的权限集合的入参为{}{}",permVOS,permVOS1);
        List<PermVO> unBindPermList = difference(permVOS, permVOS1);
        log.debug("获取此角色未绑定的权限集合的出参为{}",unBindPermList);
        return unBindPermList;
    }
    public static List<PermVO> difference(List<PermVO> listAll, List<PermVO> listByRoleId) {
        log.debug("进入difference方法用来获取未绑定权限集合");
        // 创建一个新的 ArrayList 用于存储结果
        List<PermVO> result = new ArrayList<>(listAll);

        // 将 listB 转换成一个 Set 用于快速查找
        Set<Long> idsInListB = new HashSet<>();
        for (PermVO item : listByRoleId) {
            idsInListB.add(item.getId());
        }

        // 移除所有在 listB 中出现的元素
        result.removeIf(item -> idsInListB.contains(item.getId()));

        return result;
    }

}
